1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang3;
18  
19  import static org.junit.Assert.assertEquals;
20  import static org.junit.Assert.assertFalse;
21  import static org.junit.Assert.assertThat;
22  import static org.junit.Assert.assertTrue;
23  
24  import java.util.Locale;
25  
26  import org.hamcrest.core.IsNot;
27  import org.junit.Test;
28  
29  /**
30   * Unit tests {@link org.apache.commons.lang3.StringUtils} - Substring methods
31   *
32   * @version $Id$
33   */
34  public class StringUtilsEqualsIndexOfTest  {
35      private static final String BAR = "bar";
36      /**
37       * Supplementary character U+20000
38       * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
39       */
40      private static final String CharU20000 = "\uD840\uDC00";
41      /**
42       * Supplementary character U+20001
43       * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
44       */
45      private static final String CharU20001 = "\uD840\uDC01";
46      /**
47       * Incomplete supplementary character U+20000, high surrogate only.
48       * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
49       */
50      private static final String CharUSuppCharHigh = "\uDC00";
51  
52      /**
53       * Incomplete supplementary character U+20000, low surrogate only.
54       * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
55       */
56      private static final String CharUSuppCharLow = "\uD840";
57  
58      private static final String FOO = "foo";
59  
60      private static final String FOOBAR = "foobar";
61  
62      private static final String[] FOOBAR_SUB_ARRAY = new String[] {"ob", "ba"};
63  
64      @Test
65      public void testContains_Char() {
66          assertFalse(StringUtils.contains(null, ' '));
67          assertFalse(StringUtils.contains("", ' '));
68          assertFalse(StringUtils.contains("", null));
69          assertFalse(StringUtils.contains(null, null));
70          assertTrue(StringUtils.contains("abc", 'a'));
71          assertTrue(StringUtils.contains("abc", 'b'));
72          assertTrue(StringUtils.contains("abc", 'c'));
73          assertFalse(StringUtils.contains("abc", 'z'));
74      }
75  
76      @Test
77      public void testContains_String() {
78          assertFalse(StringUtils.contains(null, null));
79          assertFalse(StringUtils.contains(null, ""));
80          assertFalse(StringUtils.contains(null, "a"));
81          assertFalse(StringUtils.contains("", null));
82          assertTrue(StringUtils.contains("", ""));
83          assertFalse(StringUtils.contains("", "a"));
84          assertTrue(StringUtils.contains("abc", "a"));
85          assertTrue(StringUtils.contains("abc", "b"));
86          assertTrue(StringUtils.contains("abc", "c"));
87          assertTrue(StringUtils.contains("abc", "abc"));
88          assertFalse(StringUtils.contains("abc", "z"));
89      }
90  
91      /**
92       * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
93       */
94      @Test
95      public void testContains_StringWithBadSupplementaryChars() {
96          // Test edge case: 1/2 of a (broken) supplementary char
97          assertFalse(StringUtils.contains(CharUSuppCharHigh, CharU20001));
98          assertFalse(StringUtils.contains(CharUSuppCharLow, CharU20001));
99          assertFalse(StringUtils.contains(CharU20001, CharUSuppCharHigh));
100         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
101         assertTrue(StringUtils.contains(CharU20001, CharUSuppCharLow));
102         assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharLow + "a", "a"));
103         assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharHigh + "a", "a"));
104     }
105 
106     /**
107      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
108      */
109     @Test
110     public void testContains_StringWithSupplementaryChars() {
111         assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20000));
112         assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20001));
113         assertTrue(StringUtils.contains(CharU20000, CharU20000));
114         assertFalse(StringUtils.contains(CharU20000, CharU20001));
115     }
116 
117     @Test
118     public void testContainsAny_StringCharArray() {
119         assertFalse(StringUtils.containsAny(null, (char[]) null));
120         assertFalse(StringUtils.containsAny(null, new char[0]));
121         assertFalse(StringUtils.containsAny(null, new char[] { 'a', 'b' }));
122 
123         assertFalse(StringUtils.containsAny("", (char[]) null));
124         assertFalse(StringUtils.containsAny("", new char[0]));
125         assertFalse(StringUtils.containsAny("", new char[] { 'a', 'b' }));
126 
127         assertFalse(StringUtils.containsAny("zzabyycdxx", (char[]) null));
128         assertFalse(StringUtils.containsAny("zzabyycdxx", new char[0]));
129         assertTrue(StringUtils.containsAny("zzabyycdxx", new char[] { 'z', 'a' }));
130         assertTrue(StringUtils.containsAny("zzabyycdxx", new char[] { 'b', 'y' }));
131         assertFalse(StringUtils.containsAny("ab", new char[] { 'z' }));
132     }
133 
134     /**
135      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
136      */
137     @Test
138     public void testContainsAny_StringCharArrayWithBadSupplementaryChars() {
139         // Test edge case: 1/2 of a (broken) supplementary char
140         assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001.toCharArray()));
141         assertFalse(StringUtils.containsAny("abc" + CharUSuppCharHigh + "xyz", CharU20001.toCharArray()));
142         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
143         assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001.toCharArray()));
144         assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh.toCharArray()));
145         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
146         assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow.toCharArray()));
147     }
148 
149     /**
150      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
151      */
152     @Test
153     public void testContainsAny_StringCharArrayWithSupplementaryChars() {
154         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
155         assertTrue(StringUtils.containsAny("a" + CharU20000 + CharU20001, "a".toCharArray()));
156         assertTrue(StringUtils.containsAny(CharU20000 + "a" + CharU20001, "a".toCharArray()));
157         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001 + "a", "a".toCharArray()));
158         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
159         assertTrue(StringUtils.containsAny(CharU20000, CharU20000.toCharArray()));
160         // Sanity check:
161         assertEquals(-1, CharU20000.indexOf(CharU20001));
162         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
163         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
164         // Test:
165         assertFalse(StringUtils.containsAny(CharU20000, CharU20001.toCharArray()));
166         assertFalse(StringUtils.containsAny(CharU20001, CharU20000.toCharArray()));
167     }
168 
169     @Test
170     public void testContainsAny_StringString() {
171         assertFalse(StringUtils.containsAny(null, (String) null));
172         assertFalse(StringUtils.containsAny(null, ""));
173         assertFalse(StringUtils.containsAny(null, "ab"));
174 
175         assertFalse(StringUtils.containsAny("", (String) null));
176         assertFalse(StringUtils.containsAny("", ""));
177         assertFalse(StringUtils.containsAny("", "ab"));
178 
179         assertFalse(StringUtils.containsAny("zzabyycdxx", (String) null));
180         assertFalse(StringUtils.containsAny("zzabyycdxx", ""));
181         assertTrue(StringUtils.containsAny("zzabyycdxx", "za"));
182         assertTrue(StringUtils.containsAny("zzabyycdxx", "by"));
183         assertFalse(StringUtils.containsAny("ab", "z"));
184     }
185 
186     /**
187      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
188      */
189     @Test
190     public void testContainsAny_StringWithBadSupplementaryChars() {
191         // Test edge case: 1/2 of a (broken) supplementary char
192         assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001));
193         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
194         assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001));
195         assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh));
196         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
197         assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow));
198     }
199 
200     /**
201      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
202      */
203     @Test
204     public void testContainsAny_StringWithSupplementaryChars() {
205         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000));
206         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001));
207         assertTrue(StringUtils.containsAny(CharU20000, CharU20000));
208         // Sanity check:
209         assertEquals(-1, CharU20000.indexOf(CharU20001));
210         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
211         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
212         // Test:
213         assertFalse(StringUtils.containsAny(CharU20000, CharU20001));
214         assertFalse(StringUtils.containsAny(CharU20001, CharU20000));
215     }
216     
217     @Test
218     public void testContainsAny_StringStringArray() {
219         assertFalse(StringUtils.containsAny(null, (String[]) null));
220         assertFalse(StringUtils.containsAny(null, new String[0]));
221         assertFalse(StringUtils.containsAny(null, new String[] { "hello" }));
222         assertFalse(StringUtils.containsAny("", (String[]) null));
223         assertFalse(StringUtils.containsAny("", new String[0]));
224         assertFalse(StringUtils.containsAny("", new String[] { "hello" }));
225         assertFalse(StringUtils.containsAny("hello, goodbye", (String[]) null));
226         assertFalse(StringUtils.containsAny("hello, goodbye", new String[0]));
227         assertTrue(StringUtils.containsAny("hello, goodbye", new String[] { "hello", "goodbye" }));
228         assertTrue(StringUtils.containsAny("hello, goodbye", new String[] { "hello", "Goodbye" }));
229         assertFalse(StringUtils.containsAny("hello, goodbye", new String[] { "Hello", "Goodbye" }));
230     }
231 
232     @Test
233     public void testContainsIgnoreCase_LocaleIndependence() {
234         final Locale orig = Locale.getDefault();
235 
236         final Locale[] locales = { Locale.ENGLISH, new Locale("tr"), Locale.getDefault() };
237 
238         final String[][] tdata = {
239             { "i", "I" },
240             { "I", "i" },
241             { "\u03C2", "\u03C3" },
242             { "\u03A3", "\u03C2" },
243             { "\u03A3", "\u03C3" },
244         };
245 
246         final String[][] fdata = {
247             { "\u00DF", "SS" },
248         };
249 
250         try {
251             for (final Locale locale : locales) {
252                 Locale.setDefault(locale);
253                 for (int j = 0; j < tdata.length; j++) {
254                     assertTrue(Locale.getDefault() + ": " + j + " " + tdata[j][0] + " " + tdata[j][1], StringUtils
255                             .containsIgnoreCase(tdata[j][0], tdata[j][1]));
256                 }
257                 for (int j = 0; j < fdata.length; j++) {
258                     assertFalse(Locale.getDefault() + ": " + j + " " + fdata[j][0] + " " + fdata[j][1], StringUtils
259                             .containsIgnoreCase(fdata[j][0], fdata[j][1]));
260                 }
261             }
262         } finally {
263             Locale.setDefault(orig);
264         }
265     }
266 
267     @Test
268     public void testContainsIgnoreCase_StringString() {
269         assertFalse(StringUtils.containsIgnoreCase(null, null));
270 
271         // Null tests
272         assertFalse(StringUtils.containsIgnoreCase(null, ""));
273         assertFalse(StringUtils.containsIgnoreCase(null, "a"));
274         assertFalse(StringUtils.containsIgnoreCase(null, "abc"));
275 
276         assertFalse(StringUtils.containsIgnoreCase("", null));
277         assertFalse(StringUtils.containsIgnoreCase("a", null));
278         assertFalse(StringUtils.containsIgnoreCase("abc", null));
279 
280         // Match len = 0
281         assertTrue(StringUtils.containsIgnoreCase("", ""));
282         assertTrue(StringUtils.containsIgnoreCase("a", ""));
283         assertTrue(StringUtils.containsIgnoreCase("abc", ""));
284 
285         // Match len = 1
286         assertFalse(StringUtils.containsIgnoreCase("", "a"));
287         assertTrue(StringUtils.containsIgnoreCase("a", "a"));
288         assertTrue(StringUtils.containsIgnoreCase("abc", "a"));
289         assertFalse(StringUtils.containsIgnoreCase("", "A"));
290         assertTrue(StringUtils.containsIgnoreCase("a", "A"));
291         assertTrue(StringUtils.containsIgnoreCase("abc", "A"));
292 
293         // Match len > 1
294         assertFalse(StringUtils.containsIgnoreCase("", "abc"));
295         assertFalse(StringUtils.containsIgnoreCase("a", "abc"));
296         assertTrue(StringUtils.containsIgnoreCase("xabcz", "abc"));
297         assertFalse(StringUtils.containsIgnoreCase("", "ABC"));
298         assertFalse(StringUtils.containsIgnoreCase("a", "ABC"));
299         assertTrue(StringUtils.containsIgnoreCase("xabcz", "ABC"));
300     }
301 
302     @Test
303     public void testContainsNone_CharArray() {
304         final String str1 = "a";
305         final String str2 = "b";
306         final String str3 = "ab.";
307         final char[] chars1= {'b'};
308         final char[] chars2= {'.'};
309         final char[] chars3= {'c', 'd'};
310         final char[] emptyChars = new char[0];
311         assertTrue(StringUtils.containsNone(null, (char[]) null));
312         assertTrue(StringUtils.containsNone("", (char[]) null));
313         assertTrue(StringUtils.containsNone(null, emptyChars));
314         assertTrue(StringUtils.containsNone(str1, emptyChars));
315         assertTrue(StringUtils.containsNone("", emptyChars));
316         assertTrue(StringUtils.containsNone("", chars1));
317         assertTrue(StringUtils.containsNone(str1, chars1));
318         assertTrue(StringUtils.containsNone(str1, chars2));
319         assertTrue(StringUtils.containsNone(str1, chars3));
320         assertFalse(StringUtils.containsNone(str2, chars1));
321         assertTrue(StringUtils.containsNone(str2, chars2));
322         assertTrue(StringUtils.containsNone(str2, chars3));
323         assertFalse(StringUtils.containsNone(str3, chars1));
324         assertFalse(StringUtils.containsNone(str3, chars2));
325         assertTrue(StringUtils.containsNone(str3, chars3));
326     }
327 
328     /**
329      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
330      */
331     @Test
332     public void testContainsNone_CharArrayWithBadSupplementaryChars() {
333         // Test edge case: 1/2 of a (broken) supplementary char
334         assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
335         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
336         assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
337         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
338         assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
339         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
340         assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
341     }
342 
343     /**
344      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
345      */
346     @Test
347     public void testContainsNone_CharArrayWithSupplementaryChars() {
348         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
349         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
350         assertFalse(StringUtils.containsNone(CharU20000, CharU20000.toCharArray()));
351         // Sanity check:
352         assertEquals(-1, CharU20000.indexOf(CharU20001));
353         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
354         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
355         // Test:
356         assertTrue(StringUtils.containsNone(CharU20000, CharU20001.toCharArray()));
357         assertTrue(StringUtils.containsNone(CharU20001, CharU20000.toCharArray()));
358     }
359 
360     @Test
361     public void testContainsNone_String() {
362         final String str1 = "a";
363         final String str2 = "b";
364         final String str3 = "ab.";
365         final String chars1= "b";
366         final String chars2= ".";
367         final String chars3= "cd";
368         assertTrue(StringUtils.containsNone(null, (String) null));
369         assertTrue(StringUtils.containsNone("", (String) null));
370         assertTrue(StringUtils.containsNone(null, ""));
371         assertTrue(StringUtils.containsNone(str1, ""));
372         assertTrue(StringUtils.containsNone("", ""));
373         assertTrue(StringUtils.containsNone("", chars1));
374         assertTrue(StringUtils.containsNone(str1, chars1));
375         assertTrue(StringUtils.containsNone(str1, chars2));
376         assertTrue(StringUtils.containsNone(str1, chars3));
377         assertFalse(StringUtils.containsNone(str2, chars1));
378         assertTrue(StringUtils.containsNone(str2, chars2));
379         assertTrue(StringUtils.containsNone(str2, chars3));
380         assertFalse(StringUtils.containsNone(str3, chars1));
381         assertFalse(StringUtils.containsNone(str3, chars2));
382         assertTrue(StringUtils.containsNone(str3, chars3));
383     }
384 
385     /**
386      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
387      */
388     @Test
389     public void testContainsNone_StringWithBadSupplementaryChars() {
390         // Test edge case: 1/2 of a (broken) supplementary char
391         assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001));
392         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
393         assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001));
394         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
395         assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh));
396         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
397         assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow));
398     }
399 
400     /**
401      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
402      */
403     @Test
404     public void testContainsNone_StringWithSupplementaryChars() {
405         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000));
406         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001));
407         assertFalse(StringUtils.containsNone(CharU20000, CharU20000));
408         // Sanity check:
409         assertEquals(-1, CharU20000.indexOf(CharU20001));
410         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
411         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
412         // Test:
413         assertTrue(StringUtils.containsNone(CharU20000, CharU20001));
414         assertTrue(StringUtils.containsNone(CharU20001, CharU20000));
415     }
416 
417     @Test
418     public void testContainsOnly_CharArray() {
419         final String str1 = "a";
420         final String str2 = "b";
421         final String str3 = "ab";
422         final char[] chars1= {'b'};
423         final char[] chars2= {'a'};
424         final char[] chars3= {'a', 'b'};
425         final char[] emptyChars = new char[0];
426         assertFalse(StringUtils.containsOnly(null, (char[]) null));
427         assertFalse(StringUtils.containsOnly("", (char[]) null));
428         assertFalse(StringUtils.containsOnly(null, emptyChars));
429         assertFalse(StringUtils.containsOnly(str1, emptyChars));
430         assertTrue(StringUtils.containsOnly("", emptyChars));
431         assertTrue(StringUtils.containsOnly("", chars1));
432         assertFalse(StringUtils.containsOnly(str1, chars1));
433         assertTrue(StringUtils.containsOnly(str1, chars2));
434         assertTrue(StringUtils.containsOnly(str1, chars3));
435         assertTrue(StringUtils.containsOnly(str2, chars1));
436         assertFalse(StringUtils.containsOnly(str2, chars2));
437         assertTrue(StringUtils.containsOnly(str2, chars3));
438         assertFalse(StringUtils.containsOnly(str3, chars1));
439         assertFalse(StringUtils.containsOnly(str3, chars2));
440         assertTrue(StringUtils.containsOnly(str3, chars3));
441     }
442 
443     @Test
444     public void testContainsOnly_String() {
445         final String str1 = "a";
446         final String str2 = "b";
447         final String str3 = "ab";
448         final String chars1= "b";
449         final String chars2= "a";
450         final String chars3= "ab";
451         assertFalse(StringUtils.containsOnly(null, (String) null));
452         assertFalse(StringUtils.containsOnly("", (String) null));
453         assertFalse(StringUtils.containsOnly(null, ""));
454         assertFalse(StringUtils.containsOnly(str1, ""));
455         assertTrue(StringUtils.containsOnly("", ""));
456         assertTrue(StringUtils.containsOnly("", chars1));
457         assertFalse(StringUtils.containsOnly(str1, chars1));
458         assertTrue(StringUtils.containsOnly(str1, chars2));
459         assertTrue(StringUtils.containsOnly(str1, chars3));
460         assertTrue(StringUtils.containsOnly(str2, chars1));
461         assertFalse(StringUtils.containsOnly(str2, chars2));
462         assertTrue(StringUtils.containsOnly(str2, chars3));
463         assertFalse(StringUtils.containsOnly(str3, chars1));
464         assertFalse(StringUtils.containsOnly(str3, chars2));
465         assertTrue(StringUtils.containsOnly(str3, chars3));
466     }
467 
468     @Test
469     public void testContainsWhitespace() {
470         assertFalse( StringUtils.containsWhitespace("") );
471         assertTrue( StringUtils.containsWhitespace(" ") );
472         assertFalse( StringUtils.containsWhitespace("a") );
473         assertTrue( StringUtils.containsWhitespace("a ") );
474         assertTrue( StringUtils.containsWhitespace(" a") );
475         assertTrue( StringUtils.containsWhitespace("a\t") );
476         assertTrue( StringUtils.containsWhitespace("\n") );
477     }
478 
479     // The purpose of this class is to test StringUtils#equals(CharSequence, CharSequence)
480     // with a CharSequence implementation whose equals(Object) override requires that the
481     // other object be an instance of CustomCharSequence, even though, as char sequences,
482     // `seq` may equal the other object.
483     private static class CustomCharSequence implements CharSequence {
484         private final CharSequence seq;
485 
486         public CustomCharSequence(final CharSequence seq) {
487             this.seq = seq;
488         }
489 
490         @Override
491         public char charAt(final int index) {
492             return seq.charAt(index);
493         }
494 
495         @Override
496         public int length() {
497             return seq.length();
498         }
499 
500         @Override
501         public CharSequence subSequence(final int start, final int end) {
502             return new CustomCharSequence(seq.subSequence(start, end));
503         }
504 
505         @Override
506         public boolean equals(final Object obj) {
507             if (obj == null || !(obj instanceof CustomCharSequence)) {
508                 return false;
509             }
510             final CustomCharSequence other = (CustomCharSequence) obj;
511             return seq.equals(other.seq);
512         }
513 
514         @Override
515         public int hashCode() {
516             return seq.hashCode();
517         }
518 
519         @Override
520         public String toString() {
521             return seq.toString();
522         }
523     }
524 
525     @Test
526     public void testCustomCharSequence() {
527         assertThat(new CustomCharSequence(FOO), IsNot.<CharSequence>not(FOO));
528         assertThat(FOO, IsNot.<CharSequence>not(new CustomCharSequence(FOO)));
529         assertEquals(new CustomCharSequence(FOO), new CustomCharSequence(FOO));
530     }
531 
532     @Test
533     public void testEquals() {
534         final CharSequence fooCs = FOO, barCs = BAR, foobarCs = FOOBAR;
535         assertTrue(StringUtils.equals(null, null));
536         assertTrue(StringUtils.equals(fooCs, fooCs));
537         assertTrue(StringUtils.equals(fooCs, new StringBuilder(FOO)));
538         assertTrue(StringUtils.equals(fooCs, new String(new char[] { 'f', 'o', 'o' })));
539         assertTrue(StringUtils.equals(fooCs, new CustomCharSequence(FOO)));
540         assertTrue(StringUtils.equals(new CustomCharSequence(FOO), fooCs));
541         assertFalse(StringUtils.equals(fooCs, new String(new char[] { 'f', 'O', 'O' })));
542         assertFalse(StringUtils.equals(fooCs, barCs));
543         assertFalse(StringUtils.equals(fooCs, null));
544         assertFalse(StringUtils.equals(null, fooCs));
545         assertFalse(StringUtils.equals(fooCs, foobarCs));
546         assertFalse(StringUtils.equals(foobarCs, fooCs));
547     }
548 
549     @Test
550     public void testEqualsOnStrings() {
551         assertTrue(StringUtils.equals(null, null));
552         assertTrue(StringUtils.equals(FOO, FOO));
553         assertTrue(StringUtils.equals(FOO, new String(new char[] { 'f', 'o', 'o' })));
554         assertFalse(StringUtils.equals(FOO, new String(new char[] { 'f', 'O', 'O' })));
555         assertFalse(StringUtils.equals(FOO, BAR));
556         assertFalse(StringUtils.equals(FOO, null));
557         assertFalse(StringUtils.equals(null, FOO));
558         assertFalse(StringUtils.equals(FOO, FOOBAR));
559         assertFalse(StringUtils.equals(FOOBAR, FOO));
560     }
561 
562     @Test
563     public void testEqualsIgnoreCase() {
564         assertTrue(StringUtils.equalsIgnoreCase(null, null));
565         assertTrue(StringUtils.equalsIgnoreCase(FOO, FOO));
566         assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'o', 'o' })));
567         assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'O', 'O' })));
568         assertFalse(StringUtils.equalsIgnoreCase(FOO, BAR));
569         assertFalse(StringUtils.equalsIgnoreCase(FOO, null));
570         assertFalse(StringUtils.equalsIgnoreCase(null, FOO));
571         assertTrue(StringUtils.equalsIgnoreCase("",""));
572         assertFalse(StringUtils.equalsIgnoreCase("abcd","abcd "));
573     }
574 
575     //-----------------------------------------------------------------------
576     @Test
577     public void testIndexOf_char() {
578         assertEquals(-1, StringUtils.indexOf(null, ' '));
579         assertEquals(-1, StringUtils.indexOf("", ' '));
580         assertEquals(0, StringUtils.indexOf("aabaabaa", 'a'));
581         assertEquals(2, StringUtils.indexOf("aabaabaa", 'b'));
582 
583         assertEquals(2, StringUtils.indexOf(new StringBuilder("aabaabaa"), 'b'));
584     }
585 
586     @Test
587     public void testIndexOf_charInt() {
588         assertEquals(-1, StringUtils.indexOf(null, ' ', 0));
589         assertEquals(-1, StringUtils.indexOf(null, ' ', -1));
590         assertEquals(-1, StringUtils.indexOf("", ' ', 0));
591         assertEquals(-1, StringUtils.indexOf("", ' ', -1));
592         assertEquals(0, StringUtils.indexOf("aabaabaa", 'a', 0));
593         assertEquals(2, StringUtils.indexOf("aabaabaa", 'b', 0));
594         assertEquals(5, StringUtils.indexOf("aabaabaa", 'b', 3));
595         assertEquals(-1, StringUtils.indexOf("aabaabaa", 'b', 9));
596         assertEquals(2, StringUtils.indexOf("aabaabaa", 'b', -1));
597 
598         assertEquals(5, StringUtils.indexOf(new StringBuilder("aabaabaa"), 'b', 3));
599     }
600 
601     @Test
602     public void testIndexOf_String() {
603         assertEquals(-1, StringUtils.indexOf(null, null));
604         assertEquals(-1, StringUtils.indexOf("", null));
605         assertEquals(0, StringUtils.indexOf("", ""));
606         assertEquals(0, StringUtils.indexOf("aabaabaa", "a"));
607         assertEquals(2, StringUtils.indexOf("aabaabaa", "b"));
608         assertEquals(1, StringUtils.indexOf("aabaabaa", "ab"));
609         assertEquals(0, StringUtils.indexOf("aabaabaa", ""));
610 
611         assertEquals(2, StringUtils.indexOf(new StringBuilder("aabaabaa"), "b"));
612     }
613 
614     @Test
615     public void testIndexOf_StringInt() {
616         assertEquals(-1, StringUtils.indexOf(null, null, 0));
617         assertEquals(-1, StringUtils.indexOf(null, null, -1));
618         assertEquals(-1, StringUtils.indexOf(null, "", 0));
619         assertEquals(-1, StringUtils.indexOf(null, "", -1));
620         assertEquals(-1, StringUtils.indexOf("", null, 0));
621         assertEquals(-1, StringUtils.indexOf("", null, -1));
622         assertEquals(0, StringUtils.indexOf("", "", 0));
623         assertEquals(0, StringUtils.indexOf("", "", -1));
624         assertEquals(0, StringUtils.indexOf("", "", 9));
625         assertEquals(0, StringUtils.indexOf("abc", "", 0));
626         assertEquals(0, StringUtils.indexOf("abc", "", -1));
627         assertEquals(3, StringUtils.indexOf("abc", "", 9));
628         assertEquals(3, StringUtils.indexOf("abc", "", 3));
629         assertEquals(0, StringUtils.indexOf("aabaabaa", "a", 0));
630         assertEquals(2, StringUtils.indexOf("aabaabaa", "b", 0));
631         assertEquals(1, StringUtils.indexOf("aabaabaa", "ab", 0));
632         assertEquals(5, StringUtils.indexOf("aabaabaa", "b", 3));
633         assertEquals(-1, StringUtils.indexOf("aabaabaa", "b", 9));
634         assertEquals(2, StringUtils.indexOf("aabaabaa", "b", -1));
635         assertEquals(2,StringUtils.indexOf("aabaabaa", "", 2));
636 
637         // Test that startIndex works correctly, i.e. cannot match before startIndex
638         assertEquals(7, StringUtils.indexOf("12345678", "8", 5));
639         assertEquals(7, StringUtils.indexOf("12345678", "8", 6));
640         assertEquals(7, StringUtils.indexOf("12345678", "8", 7)); // 7 is last index
641         assertEquals(-1, StringUtils.indexOf("12345678", "8", 8));
642 
643         assertEquals(5, StringUtils.indexOf(new StringBuilder("aabaabaa"), "b", 3));
644     }
645 
646     @Test
647     public void testIndexOfAny_StringCharArray() {
648         assertEquals(-1, StringUtils.indexOfAny(null, (char[]) null));
649         assertEquals(-1, StringUtils.indexOfAny(null, new char[0]));
650         assertEquals(-1, StringUtils.indexOfAny(null, new char[] {'a','b'}));
651 
652         assertEquals(-1, StringUtils.indexOfAny("", (char[]) null));
653         assertEquals(-1, StringUtils.indexOfAny("", new char[0]));
654         assertEquals(-1, StringUtils.indexOfAny("", new char[] {'a','b'}));
655 
656         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", (char[]) null));
657         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", new char[0]));
658         assertEquals(0, StringUtils.indexOfAny("zzabyycdxx", new char[] {'z','a'}));
659         assertEquals(3, StringUtils.indexOfAny("zzabyycdxx", new char[] {'b','y'}));
660         assertEquals(-1, StringUtils.indexOfAny("ab", new char[] {'z'}));
661     }
662 
663     /**
664      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
665      */
666     @Test
667     public void testIndexOfAny_StringCharArrayWithSupplementaryChars() {
668         assertEquals(0, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
669         assertEquals(2, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
670         assertEquals(0, StringUtils.indexOfAny(CharU20000, CharU20000.toCharArray()));
671         assertEquals(-1, StringUtils.indexOfAny(CharU20000, CharU20001.toCharArray()));
672     }
673 
674     @Test
675     public void testIndexOfAny_StringString() {
676         assertEquals(-1, StringUtils.indexOfAny(null, (String) null));
677         assertEquals(-1, StringUtils.indexOfAny(null, ""));
678         assertEquals(-1, StringUtils.indexOfAny(null, "ab"));
679 
680         assertEquals(-1, StringUtils.indexOfAny("", (String) null));
681         assertEquals(-1, StringUtils.indexOfAny("", ""));
682         assertEquals(-1, StringUtils.indexOfAny("", "ab"));
683 
684         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", (String) null));
685         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", ""));
686         assertEquals(0, StringUtils.indexOfAny("zzabyycdxx", "za"));
687         assertEquals(3, StringUtils.indexOfAny("zzabyycdxx", "by"));
688         assertEquals(-1, StringUtils.indexOfAny("ab", "z"));
689     }
690 
691     @Test
692     public void testIndexOfAny_StringStringArray() {
693         assertEquals(-1, StringUtils.indexOfAny(null, (String[]) null));
694         assertEquals(-1, StringUtils.indexOfAny(null, FOOBAR_SUB_ARRAY));
695         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, (String[]) null));
696         assertEquals(2, StringUtils.indexOfAny(FOOBAR, FOOBAR_SUB_ARRAY));
697         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[0]));
698         assertEquals(-1, StringUtils.indexOfAny(null, new String[0]));
699         assertEquals(-1, StringUtils.indexOfAny("", new String[0]));
700         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[] {"llll"}));
701         assertEquals(0, StringUtils.indexOfAny(FOOBAR, new String[] {""}));
702         assertEquals(0, StringUtils.indexOfAny("", new String[] {""}));
703         assertEquals(-1, StringUtils.indexOfAny("", new String[] {"a"}));
704         assertEquals(-1, StringUtils.indexOfAny("", new String[] {null}));
705         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[] {null}));
706         assertEquals(-1, StringUtils.indexOfAny(null, new String[] {null}));
707     }
708 
709     /**
710      * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
711      */
712     @Test
713     public void testIndexOfAny_StringStringWithSupplementaryChars() {
714         assertEquals(0, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20000));
715         assertEquals(2, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20001));
716         assertEquals(0, StringUtils.indexOfAny(CharU20000, CharU20000));
717         assertEquals(-1, StringUtils.indexOfAny(CharU20000, CharU20001));
718     }
719 
720     @Test
721     public void testIndexOfAnyBut_StringCharArray() {
722         assertEquals(-1, StringUtils.indexOfAnyBut(null, (char[]) null));
723         assertEquals(-1, StringUtils.indexOfAnyBut(null, new char[0]));
724         assertEquals(-1, StringUtils.indexOfAnyBut(null, new char[] {'a','b'}));
725 
726         assertEquals(-1, StringUtils.indexOfAnyBut("", (char[]) null));
727         assertEquals(-1, StringUtils.indexOfAnyBut("", new char[0]));
728         assertEquals(-1, StringUtils.indexOfAnyBut("", new char[] {'a','b'}));
729 
730         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", (char[]) null));
731         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", new char[0]));
732         assertEquals(3, StringUtils.indexOfAnyBut("zzabyycdxx", new char[] {'z','a'}));
733         assertEquals(0, StringUtils.indexOfAnyBut("zzabyycdxx", new char[] {'b','y'}));
734         assertEquals(-1, StringUtils.indexOfAnyBut("aba", new char[] {'a', 'b'}));
735         assertEquals(0, StringUtils.indexOfAnyBut("aba", new char[] {'z'}));
736 
737     }
738 
739     @Test
740     public void testIndexOfAnyBut_StringCharArrayWithSupplementaryChars() {
741         assertEquals(2, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20000.toCharArray()));
742         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20001.toCharArray()));
743         assertEquals(-1, StringUtils.indexOfAnyBut(CharU20000, CharU20000.toCharArray()));
744         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000, CharU20001.toCharArray()));
745     }
746 
747     @Test
748     public void testIndexOfAnyBut_StringString() {
749         assertEquals(-1, StringUtils.indexOfAnyBut(null, (String) null));
750         assertEquals(-1, StringUtils.indexOfAnyBut(null, ""));
751         assertEquals(-1, StringUtils.indexOfAnyBut(null, "ab"));
752 
753         assertEquals(-1, StringUtils.indexOfAnyBut("", (String) null));
754         assertEquals(-1, StringUtils.indexOfAnyBut("", ""));
755         assertEquals(-1, StringUtils.indexOfAnyBut("", "ab"));
756 
757         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", (String) null));
758         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", ""));
759         assertEquals(3, StringUtils.indexOfAnyBut("zzabyycdxx", "za"));
760         assertEquals(0, StringUtils.indexOfAnyBut("zzabyycdxx", "by"));
761         assertEquals(0, StringUtils.indexOfAnyBut("ab", "z"));
762     }
763 
764     @Test
765     public void testIndexOfAnyBut_StringStringWithSupplementaryChars() {
766         assertEquals(2, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20000));
767         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20001));
768         assertEquals(-1, StringUtils.indexOfAnyBut(CharU20000, CharU20000));
769         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000, CharU20001));
770     }
771 
772     @Test
773     public void testIndexOfIgnoreCase_String() {
774         assertEquals(-1, StringUtils.indexOfIgnoreCase(null, null));
775         assertEquals(-1, StringUtils.indexOfIgnoreCase(null, ""));
776         assertEquals(-1, StringUtils.indexOfIgnoreCase("", null));
777         assertEquals(0, StringUtils.indexOfIgnoreCase("", ""));
778         assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", "a"));
779         assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", "A"));
780         assertEquals(2, StringUtils.indexOfIgnoreCase("aabaabaa", "b"));
781         assertEquals(2, StringUtils.indexOfIgnoreCase("aabaabaa", "B"));
782         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "ab"));
783         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB"));
784         assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", ""));
785     }
786 
787     @Test
788     public void testIndexOfIgnoreCase_StringInt() {
789         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", -1));
790         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0));
791         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 1));
792         assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 2));
793         assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 3));
794         assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 4));
795         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 5));
796         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 6));
797         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 7));
798         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 8));
799         assertEquals(1, StringUtils.indexOfIgnoreCase("aab", "AB", 1));
800         assertEquals(5, StringUtils.indexOfIgnoreCase("aabaabaa", "", 5));
801         assertEquals(-1, StringUtils.indexOfIgnoreCase("ab", "AAB", 0));
802         assertEquals(-1, StringUtils.indexOfIgnoreCase("aab", "AAB", 1));
803     }
804 
805     @Test
806     public void testLastIndexOf_char() {
807         assertEquals(-1, StringUtils.lastIndexOf(null, ' '));
808         assertEquals(-1, StringUtils.lastIndexOf("", ' '));
809         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a'));
810         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b'));
811 
812         assertEquals(5, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b'));
813     }
814 
815     @Test
816     public void testLastIndexOf_charInt() {
817         assertEquals(-1, StringUtils.lastIndexOf(null, ' ', 0));
818         assertEquals(-1, StringUtils.lastIndexOf(null, ' ', -1));
819         assertEquals(-1, StringUtils.lastIndexOf("", ' ', 0));
820         assertEquals(-1, StringUtils.lastIndexOf("", ' ', -1));
821         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a', 8));
822         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 8));
823         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", 'b', 3));
824         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 9));
825         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", 'b', -1));
826         assertEquals(0, StringUtils.lastIndexOf("aabaabaa", 'a', 0));
827 
828         assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b', 2));
829     }
830 
831     @Test
832     public void testLastIndexOf_String() {
833         assertEquals(-1, StringUtils.lastIndexOf(null, null));
834         assertEquals(-1, StringUtils.lastIndexOf("", null));
835         assertEquals(-1, StringUtils.lastIndexOf("", "a"));
836         assertEquals(0, StringUtils.lastIndexOf("", ""));
837         assertEquals(8, StringUtils.lastIndexOf("aabaabaa", ""));
838         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a"));
839         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b"));
840         assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab"));
841 
842         assertEquals(4, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "ab"));
843     }
844 
845     @Test
846     public void testLastIndexOf_StringInt() {
847         assertEquals(-1, StringUtils.lastIndexOf(null, null, 0));
848         assertEquals(-1, StringUtils.lastIndexOf(null, null, -1));
849         assertEquals(-1, StringUtils.lastIndexOf(null, "", 0));
850         assertEquals(-1, StringUtils.lastIndexOf(null, "", -1));
851         assertEquals(-1, StringUtils.lastIndexOf("", null, 0));
852         assertEquals(-1, StringUtils.lastIndexOf("", null, -1));
853         assertEquals(0, StringUtils.lastIndexOf("", "", 0));
854         assertEquals(-1, StringUtils.lastIndexOf("", "", -1));
855         assertEquals(0, StringUtils.lastIndexOf("", "", 9));
856         assertEquals(0, StringUtils.lastIndexOf("abc", "", 0));
857         assertEquals(-1, StringUtils.lastIndexOf("abc", "", -1));
858         assertEquals(3, StringUtils.lastIndexOf("abc", "", 9));
859         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a", 8));
860         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 8));
861         assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab", 8));
862         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 3));
863         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 9));
864         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", -1));
865         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 0));
866         assertEquals(0, StringUtils.lastIndexOf("aabaabaa", "a", 0));
867         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "a", -1));
868 
869         // Test that fromIndex works correctly, i.e. cannot match after fromIndex
870         assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 9));
871         assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 8));
872         assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 7)); // 7 is last index
873         assertEquals(-1, StringUtils.lastIndexOf("12345678", "8", 6));
874 
875         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 1));
876         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 2));
877         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 2));
878         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 3));
879 
880         assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "b", 3));
881     }
882 
883     @Test
884     public void testLastIndexOfAny_StringStringArray() {
885         assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence) null));   // test both types of ...
886         assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence[]) null)); // ... varargs invocation
887         assertEquals(-1, StringUtils.lastIndexOfAny(null)); // Missing varag
888         assertEquals(-1, StringUtils.lastIndexOfAny(null, FOOBAR_SUB_ARRAY));
889         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence) null));   // test both types of ...
890         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence[]) null)); // ... varargs invocation
891         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR)); // Missing vararg
892         assertEquals(3, StringUtils.lastIndexOfAny(FOOBAR, FOOBAR_SUB_ARRAY));
893         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[0]));
894         assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[0]));
895         assertEquals(-1, StringUtils.lastIndexOfAny("", new String[0]));
896         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {"llll"}));
897         assertEquals(6, StringUtils.lastIndexOfAny(FOOBAR, new String[] {""}));
898         assertEquals(0, StringUtils.lastIndexOfAny("", new String[] {""}));
899         assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {"a"}));
900         assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {null}));
901         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {null}));
902         assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[] {null}));
903     }
904 
905     @Test
906     public void testLastIndexOfIgnoreCase_String() {
907         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null));
908         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null));
909         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, ""));
910         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "a"));
911         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", ""));
912         assertEquals(8, StringUtils.lastIndexOfIgnoreCase("aabaabaa", ""));
913         assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "a"));
914         assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A"));
915         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "b"));
916         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B"));
917         assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "ab"));
918         assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB"));
919         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("ab", "AAB"));
920         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aab", "AAB"));
921     }
922 
923     @Test
924     public void testLastIndexOfIgnoreCase_StringInt() {
925         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, 0));
926         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, -1));
927         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", 0));
928         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", -1));
929         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, 0));
930         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, -1));
931         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 0));
932         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "", -1));
933         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 9));
934         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("abc", "", 0));
935         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("abc", "", -1));
936         assertEquals(3, StringUtils.lastIndexOfIgnoreCase("abc", "", 9));
937         assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8));
938         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8));
939         assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8));
940         assertEquals(2, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 3));
941         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9));
942         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1));
943         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0));
944         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0));
945         assertEquals(1, StringUtils.lastIndexOfIgnoreCase("aab", "AB", 1));
946     }
947 
948     @Test
949     public void testLastOrdinalIndexOf() {
950         assertEquals(-1, StringUtils.lastOrdinalIndexOf(null, "*", 42) );
951         assertEquals(-1, StringUtils.lastOrdinalIndexOf("*", null, 42) );
952         assertEquals(0, StringUtils.lastOrdinalIndexOf("", "", 42) );
953         assertEquals(7, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1) );
954         assertEquals(6, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2) );
955         assertEquals(5, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1) );
956         assertEquals(2, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2) );
957         assertEquals(4, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) );
958         assertEquals(1, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) );
959         assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1) );
960         assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2) );
961     }
962 
963     @Test
964     public void testOrdinalIndexOf() {
965         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MIN_VALUE));
966         assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MIN_VALUE));
967         assertEquals(-1, StringUtils.ordinalIndexOf("", "", Integer.MIN_VALUE));
968         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MIN_VALUE));
969         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MIN_VALUE));
970         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MIN_VALUE));
971         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MIN_VALUE));
972 
973         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, -1));
974         assertEquals(-1, StringUtils.ordinalIndexOf("", null, -1));
975         assertEquals(-1, StringUtils.ordinalIndexOf("", "", -1));
976         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", -1));
977         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", -1));
978         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", -1));
979         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", -1));
980 
981         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 0));
982         assertEquals(-1, StringUtils.ordinalIndexOf("", null, 0));
983         assertEquals(-1, StringUtils.ordinalIndexOf("", "", 0));
984         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", 0));
985         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", 0));
986         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 0));
987         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", 0));
988 
989         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 1));
990         assertEquals(-1, StringUtils.ordinalIndexOf("", null, 1));
991         assertEquals(0, StringUtils.ordinalIndexOf("", "", 1));
992         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "a", 1));
993         assertEquals(2, StringUtils.ordinalIndexOf("aabaabaa", "b", 1));
994         assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 1));
995         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 1));
996 
997         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 2));
998         assertEquals(-1, StringUtils.ordinalIndexOf("", null, 2));
999         assertEquals(0, StringUtils.ordinalIndexOf("", "", 2));
1000         assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "a", 2));
1001         assertEquals(5, StringUtils.ordinalIndexOf("aabaabaa", "b", 2));
1002         assertEquals(4, StringUtils.ordinalIndexOf("aabaabaa", "ab", 2));
1003         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 2));
1004 
1005         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MAX_VALUE));
1006         assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MAX_VALUE));
1007         assertEquals(0, StringUtils.ordinalIndexOf("", "", Integer.MAX_VALUE));
1008         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MAX_VALUE));
1009         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MAX_VALUE));
1010         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MAX_VALUE));
1011         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MAX_VALUE));
1012 
1013         assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 0));
1014         assertEquals(0, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 1));
1015         assertEquals(1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 2));
1016         assertEquals(2, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 3));
1017         assertEquals(3, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 4));
1018         assertEquals(4, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 5));
1019         assertEquals(5, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 6));
1020         assertEquals(6, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 7));
1021         assertEquals(7, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 8));
1022         assertEquals(8, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 9));
1023         assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 10));
1024 
1025         assertEquals(3, StringUtils.ordinalIndexOf("aaaaaa", "aa", 2));
1026         assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaa", "aa", 3));
1027     }
1028 
1029 }